{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Graph representation learning through Unsupervised GraphSAGE  \n",
    "### and using it for paper classification on Cora citation dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Stellargraph Unsupervised GraphSAGE is the implementation of GraphSAGE method outlined in the paper: ***[Inductive Representation Learning on Large Graphs.](http://snap.stanford.edu/graphsage/)*** W.L. Hamilton, R. Ying, and J. Leskovec arXiv:1706.02216\n",
    "[cs.SI], 2017. \n",
    "\n",
    "This notebook is a short demo of how Stellargraph Unsupervised GraphSAGE can be used to learn embeddings of the nodes representing papers in the [CORA citation network](https://linqs-data.soe.ucsc.edu/public/lbc/cora.tgz). Furthermore, this notebook demonstrates the use of the learnt embeddings in a downstream node classification task (classifying papers by subject). Note that the node embeddings can also be used in other graph machine learning tasks, such as link prediction, community detection, etc.\n",
    "\n",
    "### Unsupervised GraphSAGE:\n",
    "\n",
    "A high-level explanation of the unsupervised GraphSAGE method of graph representation learning is as follows.\n",
    "\n",
    "Objective: *Given a graph, learn embeddings of the nodes using only the graph structure and the node features, without using any known node class labels* (hence \"unsupervised\"; for semi-supervised learning of node embeddings, see this [demo](https://github.com/stellargraph/stellargraph/tree/master/demos/node-classification/graphsage/graphsage-cora-node-classification-example.ipynb))\n",
    "\n",
    "**Unsupervised GraphSAGE model:** In the Unsupervised GraphSAGE model, node embeddings are learnt by solving a simple classification task: given a large set of \"positive\" `(target, context)` node pairs generated from random walks performed on the graph (i.e., node pairs that co-occur within a certain context window in random walks), and an equally large set of \"negative\" node pairs that are randomly selected from the graph according to a certain distribution, learn a binary classifier that predicts whether arbitrary node pairs are likely to co-occur in a random walk performed on the graph. Through learning this simple binary node-pair-classification task, the model automatically learns an inductive mapping from attributes of nodes and their neighbors to node embeddings in a high-dimensional vector space, which preserves structural and feature similarities of the nodes. Unlike embeddings obtained by algorithms such as [`node2vec`](https://snap.stanford.edu/node2vec), this mapping is inductive: given a new node (with attributes) and its links to other nodes in the graph (which was unseen during model training), we can evaluate its embeddings without having to re-train the model. \n",
    "\n",
    "In our implementation of Unsupervised GraphSAGE, the training set of node pairs is composed of an equal number of positive and negative `(target, context)` pairs from the graph. The positive `(target, context)` pairs are the node pairs co-occuring on random walks over the graph whereas the negative node pairs are sampled randomly from a global node degree distribution of the graph.\n",
    "\n",
    "The architecture of the node pair classifier is the following. Input node pairs (with node features) are fed, together with the graph structure, into a pair of identical GraphSAGE encoders, producing a pair of node embeddings. These embeddings are then fed into a node pair classification layer, which applies a binary operator to those node embeddings (e.g., concatenating them), and passes the resulting node pair embeddings through a linear transform followed by a binary activation (e.g., sigmoid), thus predicting a binary label for the node pair. \n",
    "\n",
    "The entire model is trained end-to-end by minimizing the loss function of choice (e.g., binary cross-entropy between predicted node pair labels and true link labels) using stochastic gradient descent (SGD) updates of the model parameters, with minibatches of 'training' links generated on demand and fed into the model.\n",
    "\n",
    "Node embeddings obtained from the encoder part of the trained classifier can be used in various downstream tasks. In this demo, we show how these can be used for predicting node labels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import networkx as nx\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import os\n",
    "import random\n",
    "\n",
    "import stellargraph as sg\n",
    "from stellargraph.data import EdgeSplitter\n",
    "from stellargraph.mapper import GraphSAGELinkGenerator\n",
    "from stellargraph.layer import GraphSAGE, link_classification\n",
    "from stellargraph.data import UniformRandomWalk\n",
    "from stellargraph.data import UnsupervisedSampler\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "from tensorflow import keras\n",
    "from sklearn import preprocessing, feature_extraction, model_selection\n",
    "from sklearn.linear_model import LogisticRegressionCV, LogisticRegression\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "from stellargraph import globalvar\n",
    "\n",
    "from stellargraph import datasets\n",
    "from IPython.display import display, HTML"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loading the CORA network data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "The Cora dataset consists of 2708 scientific publications classified into one of seven classes. The citation network consists of 5429 links. Each publication in the dataset is described by a 0/1-valued word vector indicating the absence/presence of the corresponding word from the dictionary. The dictionary consists of 1433 unique words."
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "dataset = datasets.Cora()\n",
    "display(HTML(dataset.description))\n",
    "dataset.download()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load the graph from the edgelist (in `cited-paper` <- `citing-paper` order)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "edgelist = pd.read_csv(\n",
    "    os.path.join(dataset.data_directory, \"cora.cites\"),\n",
    "    sep=\"\\t\",\n",
    "    header=None,\n",
    "    names=[\"target\", \"source\"],\n",
    ")\n",
    "edgelist[\"label\"] = \"cites\"  # set the edge type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "Gnx = nx.from_pandas_edgelist(edgelist, edge_attr=\"label\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Specify the node types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "nx.set_node_attributes(Gnx, \"paper\", \"label\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load the features and subject for the nodes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "feature_names = [\"w_{}\".format(ii) for ii in range(1433)]\n",
    "column_names = feature_names + [\"subject\"]\n",
    "node_data = pd.read_csv(\n",
    "    os.path.join(dataset.data_directory, \"cora.content\"),\n",
    "    sep=\"\\t\",\n",
    "    header=None,\n",
    "    names=column_names,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The node features are all attributes except the paper subject (we will use this for plotting the embeddings later). Paper subject label are not used for unsupervised training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "node_features = node_data[feature_names]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Unsupervised GraphSAGE  with on demand sampling\n",
    "The Unsupervised GraphSAGE requires a training sample that can be either provided as a list of `(target, context)` node pairs or it can be provided with an `UnsupervisedSampler` instance that takes care of generating positive and negative samples of node pairs on demand. In this demo we discuss the latter technique. \n",
    "\n",
    "#### UnsupervisedSampler:\n",
    "The `UnsupervisedSampler` class takes in a `Stellargraph` graph instance. The `generator` method in the `UnsupervisedSampler`  is responsible for generating equal number of positive and negative node pair samples from the graph  for training. The samples are generated by performing uniform random walks over the graph, using `UniformRandomWalk` object. Positive `(target, context)` node pairs are extracted from the walks, and for each \n",
    "positive pair a corresponding negative pair `(target, node)` is generated by randomly sampling `node` from the degree distribution of the graph. Once the `batch_size` number of samples is accumulated, the generator yields a list of positive and negative node pairs along with their respective 1/0 labels.  \n",
    "\n",
    "In the current implementation, we use uniform random walks to explore the graph structure. The length and number of walks, as well as the root nodes for starting the walks can be user-specified. The default list for root nodes is all nodes of the graph, default `number_of_walks` is 1 (at least one walk per root node), and the default `length` of walks is 2 (need at least one node beyond the root node on the walk as a potential positive context)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1. Create the Stellargraph with node features.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "G = sg.StellarGraph(Gnx, node_features=node_features)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NetworkXStellarGraph: Undirected multigraph\n",
      " Nodes: 2708, Edges: 5278\n",
      "\n",
      " Node types:\n",
      "  paper: [2708]\n",
      "    Edge types: paper-cites->paper\n",
      "\n",
      " Edge types:\n",
      "    paper-cites->paper: [5278]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(G.info())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2. Specify the other optional parameter values: root nodes, the number of walks to take per node, the length of each walk, and random seed.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "nodes = list(G.nodes())\n",
    "number_of_walks = 1\n",
    "length = 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3. Create the UnsupervisedSampler instance with the relevant parameters passed to it.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "unsupervised_samples = UnsupervisedSampler(\n",
    "    G, nodes=nodes, length=length, number_of_walks=number_of_walks\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The graph G together with the unsupervised sampler will be used to generate samples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**5. Create a node pair generator:**\n",
    "\n",
    "Next, create the node pair generator for sampling and streaming the training data to the model. The node pair generator essentially \"maps\" pairs of nodes `(target, context)` to the input of GraphSAGE: it either takes minibatches of node pairs, or an `UnsupervisedSampler` instance which generates the minibatches of node pairs on demand. The generator samples 2-hop subgraphs with `(target, context)` head nodes extracted from those pairs, and feeds them, together with the corresponding binary labels indicating which pair represent positive or negative sample, to the input layer of the node pair classifier with GraphSAGE node encoder, for SGD updates of the model parameters.\n",
    "\n",
    "Specify:\n",
    "1. The minibatch size (number of node pairs per minibatch).\n",
    "2. The number of epochs for training the model.\n",
    "3. The sizes of 1- and 2-hop neighbor samples for GraphSAGE:\n",
    "\n",
    "Note that the length of `num_samples` list defines the number of layers/iterations in the GraphSAGE encoder. In this example, we are defining a 2-layer GraphSAGE encoder."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 50\n",
    "epochs = 4\n",
    "num_samples = [10, 5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the following we show the working of node pair generator with the UnsupervisedSampler, which will generate samples on demand."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "generator = GraphSAGELinkGenerator(G, batch_size, num_samples)\n",
    "train_gen = generator.flow(unsupervised_samples)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Build the model: a 2-layer GraphSAGE encoder acting as node representation learner, with a link classification layer on concatenated (`citing-paper`, `cited-paper`) node embeddings.\n",
    "\n",
    "GraphSAGE part of the model, with hidden layer sizes of 50 for both GraphSAGE layers, a bias term, and no dropout. (Dropout can be switched on by specifying a positive dropout rate, 0 < dropout < 1).\n",
    "Note that the length of `layer_sizes` list must be equal to the length of `num_samples`, as `len(num_samples)` defines the number of hops (layers) in the GraphSAGE encoder."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "layer_sizes = [50, 50]\n",
    "graphsage = GraphSAGE(\n",
    "    layer_sizes=layer_sizes, generator=generator, bias=True, dropout=0.0, normalize=\"l2\"\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Build the model and expose input and output sockets of graphsage, for node pair inputs:\n",
    "x_inp, x_out = graphsage.build()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Final node pair classification layer that takes a pair of nodes' embeddings produced by `graphsage` encoder, applies a binary operator to them to produce the corresponding node pair embedding ('ip' for inner product; other options for the binary operator can be seen by running a cell with `?link_classification` in it), and passes it through a dense layer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "link_classification: using 'ip' method to combine node embeddings into edge embeddings\n"
     ]
    }
   ],
   "source": [
    "prediction = link_classification(\n",
    "    output_dim=1, output_act=\"sigmoid\", edge_embedding_method=\"ip\"\n",
    ")(x_out)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Stack the GraphSAGE encoder and prediction layer into a Keras model, and specify the loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = keras.Model(inputs=x_inp, outputs=prediction)\n",
    "\n",
    "model.compile(\n",
    "    optimizer=keras.optimizers.Adam(lr=1e-3),\n",
    "    loss=keras.losses.binary_crossentropy,\n",
    "    metrics=[keras.metrics.binary_accuracy],\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**6. Train the model.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/4\n",
      "434/434 [==============================] - 47s 107ms/step - loss: 0.5660 - binary_accuracy: 0.7431\n",
      "Epoch 2/4\n",
      "434/434 [==============================] - 46s 107ms/step - loss: 0.5420 - binary_accuracy: 0.7728\n",
      "Epoch 3/4\n",
      "434/434 [==============================] - 47s 107ms/step - loss: 0.5370 - binary_accuracy: 0.7834\n",
      "Epoch 4/4\n",
      "434/434 [==============================] - 46s 107ms/step - loss: 0.5340 - binary_accuracy: 0.7913\n"
     ]
    }
   ],
   "source": [
    "history = model.fit_generator(\n",
    "    train_gen,\n",
    "    epochs=epochs,\n",
    "    verbose=1,\n",
    "    use_multiprocessing=False,\n",
    "    workers=4,\n",
    "    shuffle=True,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that multiprocessing is switched off, since with a large training set of node pairs, multiprocessing can considerably slow down the training process with the data being transferred between various processes. \n",
    "\n",
    "Also, multiple workers can be used with `Keras version 2.2.4` and above, and it speeds up the training process considerably due to multi-threading."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Extracting node embeddings\n",
    "Now that the node pair classifier is trained, we can use its node encoder part as node embeddings evaluator. Below we evaluate node embeddings as activations of the output of graphsage layer stack, and visualise them, coloring nodes by their subject label."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.decomposition import PCA\n",
    "from sklearn.manifold import TSNE\n",
    "from stellargraph.mapper import GraphSAGENodeGenerator\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Building a new node-based model**\n",
    "\n",
    "The `(src, dst)` node pair classifier `model` has two identical node encoders: one for source nodes in the node pairs, the other for destination nodes in the node pairs passed to the model. We can use either of the two identical encoders to evaluate node embeddings. Below we create an embedding model by defining a new Keras model with `x_inp_src` (a list of odd elements in `x_inp`) and `x_out_src` (the 1st element in `x_out`) as input and output, respectively. Note that this model's weights are the same as those of the corresponding node encoder in the previously trained node pair classifier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_inp_src = x_inp[0::2]\n",
    "x_out_src = x_out[0]\n",
    "embedding_model = keras.Model(inputs=x_inp_src, outputs=x_out_src)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We also need a node generator to feed graph nodes to `embedding_model`. We want to evaluate node embeddings for all nodes in the graph:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "node_ids = node_data.index\n",
    "node_gen = GraphSAGENodeGenerator(G, batch_size, num_samples).flow(node_ids)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now use `node_gen` to feed all nodes into the embedding model and extract their embeddings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55/55 [==============================] - 2s 29ms/step\n"
     ]
    }
   ],
   "source": [
    "node_embeddings = embedding_model.predict_generator(node_gen, workers=4, verbose=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Visualize the node embeddings \n",
    "Next we visualize the node embeddings in 2D using t-SNE. Colors of the nodes depict their true classes (subject in the case of Cora dataset) of the nodes. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "node_subject = node_data[\"subject\"].astype(\"category\").cat.codes\n",
    "\n",
    "X = node_embeddings\n",
    "if X.shape[1] > 2:\n",
    "    transform = TSNE  # PCA\n",
    "\n",
    "    trans = transform(n_components=2)\n",
    "    emb_transformed = pd.DataFrame(trans.fit_transform(X), index=node_ids)\n",
    "    emb_transformed[\"label\"] = node_subject\n",
    "else:\n",
    "    emb_transformed = pd.DataFrame(X, index=node_ids)\n",
    "    emb_transformed = emb_transformed.rename(columns={\"0\": 0, \"1\": 1})\n",
    "    emb_transformed[\"label\"] = node_subject"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "alpha = 0.7\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(7, 7))\n",
    "ax.scatter(\n",
    "    emb_transformed[0],\n",
    "    emb_transformed[1],\n",
    "    c=emb_transformed[\"label\"].astype(\"category\"),\n",
    "    cmap=\"jet\",\n",
    "    alpha=alpha,\n",
    ")\n",
    "ax.set(aspect=\"equal\", xlabel=\"$X_1$\", ylabel=\"$X_2$\")\n",
    "plt.title(\n",
    "    \"{} visualization of GraphSAGE embeddings for cora dataset\".format(transform.__name__)\n",
    ")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The observation that same-colored nodes in the embedding space are concentrated together is indicative  of similarity of embeddings of papers on the same topics. We would emphasize here again that the node embeddings are learnt in unsupervised way, without using true class labels. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Downstream task\n",
    "\n",
    "The node embeddings calculated using the unsupervised GraphSAGE can be used as node feature vectors in a downstream task such as node classification. \n",
    "\n",
    "In this example, we will use the  node embeddings to train a simple Logistic Regression classifier to predict paper subjects in Cora dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# X will hold the 50 input features (node embeddings)\n",
    "X = node_embeddings\n",
    "# y holds the corresponding target values\n",
    "y = np.array(node_subject)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Splitting\n",
    "\n",
    "We split the data into train and test sets. \n",
    "\n",
    "We use 5% of the data for training and the remaining 95% for testing as a hold out test set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(\n",
    "    X, y, train_size=0.05, test_size=None, stratify=y\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classifier Training\n",
    "\n",
    "We train a Logistic Regression classifier on the training data. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,\n",
       "                   intercept_scaling=1, l1_ratio=None, max_iter=100,\n",
       "                   multi_class='auto', n_jobs=None, penalty='l2',\n",
       "                   random_state=None, solver='lbfgs', tol=0.0001, verbose=0,\n",
       "                   warm_start=False)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clf = LogisticRegression(verbose=0, solver=\"lbfgs\", multi_class=\"auto\")\n",
    "clf.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Predict the hold out test set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = clf.predict(X_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculate the accuracy of the classifier on the test set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7749708511465215"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy_score(y_test, y_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The obtained accuracy is pretty decent, better than that obtained by using node embeddings obtained by `node2vec` that ignores node attributes, only taking into account the graph structure (see this [demo](https://github.com/stellargraph/stellargraph/tree/master/demos/embeddings/stellargraph-node2vec.ipynb)). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Predicted classes**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2    803\n",
       "1    438\n",
       "6    367\n",
       "3    366\n",
       "0    256\n",
       "4    215\n",
       "5    128\n",
       "dtype: int64"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series(y_pred).value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**True classes**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2    818\n",
       "3    426\n",
       "1    418\n",
       "6    351\n",
       "0    298\n",
       "4    217\n",
       "5    180\n",
       "dtype: int64"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series(y).value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Uses for unsupervised graph representation learning\n",
    "1. Unsupervised GraphSAGE learns embeddings of unlabeled graph nodes. This is highly useful as most of the real-world data is typically either unlabeled, or have noisy, unreliable, or sparse labels. In such scenarios unsupervised techniques that learn low-dimensional meaningful representation of nodes in a graph by leveraging the graph structure and features of the nodes is useful.\n",
    "2. Moreover, GraphSAGE is an inductive technique that allows us to obtain embeddings of unseen nodes, without the need to re-train the embedding model. That is, instead of training individual embeddings for each node (as in algorithms such as `node2vec` that learn a look-up table of node embeddings), GraphSAGE learns a function that generates embeddings by sampling and aggregating attributes from each node's local neighborhood, and combining those with the node's own attributes."
   ]
  }
 ],
 "metadata": {
  "file_extension": ".py",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.10"
  },
  "mimetype": "text/x-python",
  "name": "python",
  "npconvert_exporter": "python",
  "pygments_lexer": "ipython3",
  "version": 3
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
